/**
 * 后半部分一样，只是前面判前后缀回文的方法改为特征向量。
 * 对于字符串S问S[0...i]是否为回文，
 * 首项将S倒过来接在S后面，记作SS，然后求出SS的特征向量。
 * 令 k 初始为N+N
 * 只有那些 k = next[k] - 1 的 S[0...k] 才是回文串
 * 对于后缀可以做类似计算
 */
#include <bits/stdc++.h>
using namespace std;

using llt = long long;
using vi = vector<int>;

template<typename IT = const char *>
void calcNext(IT begin, int n, vector<int> & next) {
    next.assign(n, 0);
    for(int i=1;i<n;++i){
        int k = next[i - 1];
        while(k > 0 and *(begin + i) != *(begin + k)){
            k = next[k - 1];
        }
        next[i] = (*(begin + i) == *(begin + k)) ? k + 1 : 0;
    }
    return;
}

void calc(int n, const vi & next, vi & possible){
    int k = n + n;
    while(1){
        k = next[k] - 1;
        if(k < 0) break;
        possible.push_back(k);
    }
    return;
}

int N, M;
string S, T;

int proc(){
    vi ffsvec(N + 1 + N + 1, 0), bbsvec(N + 1 + N + 1, 0);
    for(int i=0;i<N;++i) {
        ffsvec[i] = ffsvec[N + N - i] = S[i] - 'a' + 1;
        bbsvec[i] = bbsvec[N +N - i] = S[N - i - 1] - 'a' + 1;
    }
    ffsvec[N] = 27;
    bbsvec[N] = 27;    
    vi ffsnext, bbsnext;
    calcNext(ffsvec.begin(), ffsvec.size(), ffsnext);
    calcNext(bbsvec.begin(), bbsvec.size(), bbsnext);

    vi sprepossible, ssufpossible;
    calc(N, ffsnext, sprepossible);
    calc(N, bbsnext, ssufpossible);
    for(auto & i : ssufpossible) i = N - i - 1;
    set<int> spre(sprepossible.begin(), sprepossible.end());
    set<int> ssuf(ssufpossible.begin(), ssufpossible.end());


    vi fftvec(M + 1 + M + 1, 0), bbtvec(M + 1 + M + 1, 9);
    for(int i=0;i<M;++i) {
        fftvec[i] = fftvec[M + M - i] = T[i] - 'a' + 1;
        bbtvec[i] = bbtvec[M + M - i] = T[M - i - 1] - 'a' + 1;
    }
    bbtvec[M] = fftvec[M] = 27;
    vi fftnext, bbtnext;
    calcNext(fftvec.begin(), fftvec.size(), fftnext);  
    calcNext(bbtvec.begin(), bbtvec.size(), bbtnext);

    vi tprepossible, tsufpossible;
    calc(M, fftnext, tprepossible);
    calc(M, bbtnext, tsufpossible);
    set<int> tpre(tprepossible.begin(), tprepossible.end());
    for(auto & i : tsufpossible) i = M - i - 1;
    set<int> tsuf(tsufpossible.begin(), tsufpossible.end());

    vector<int> pre;
    for(int i=0,j=M-1;i<N&&j>=0;++i,--j){
        if(S[i] != T[j]) break;
        if(spre.count(i) and tsuf.count(j)){
            pre.push_back(i);
        }
    }

    if(pre.empty()) return -1;

    vector<int> suf;
    for(int j=0,i=N-1;i>=0&&j<M;++j,--i){
        if(S[i] != T[j]) break;
        if(tpre.count(j) and ssuf.count(i)){
            suf.push_back(i);
        }
    }

    if(suf.empty()) return -1;
    reverse(suf.begin(), suf.end());

    int limit = min(N, M);
    int ans = -1;
    for(auto i : pre){
        auto pp = equal_range(suf.begin(), suf.end(), N + i + 1 - limit);
        if(pp.first != pp.second){
            auto t = *pp.first;
            int tmp = i + 1 + N - t;
            if(-1 == ans or ans < tmp){
                ans = tmp;
            }
        }else if(pp.second != suf.end()){
            auto t = *pp.second;
            int tmp = i + 1 + N - t;
            if(-1 == ans or ans < tmp){
                ans = tmp;
            }
        }
    }
    return ans + ans;
}


int main(){
#ifndef ONLINE_JUDGE
    freopen("z.txt", "r", stdin);
#endif
    ios::sync_with_stdio(0); cin.tie(0); cout.tie(0);
    int nofkase = 1; 
    // cin >> nofkase;
    while(nofkase--){
        cin >> N >> M >> S >> T;
        cout << proc() << "\n";
    }
    return 0;
}